commit 79101aec3ad3070ad1378ca1450b72edf8ed67da
author Howard Hinnant <hhinnant@apple.com> Thu Sep 30 21:05:29 2010
committer Howard Hinnant <hhinnant@apple.com> Thu Sep 30 21:05:29 2010
tree 770b06590f9a261d8c58508ae23a7ea7cd8edc26
parent f701e25c49dbfd660ab15ceb5d0828d8b8f945e4

[atomics.flag] completed. Initialization is not working on clang and can't be made to work without defaulted default constructors. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@115207 91177308-0d34-0410-b5e6-96231b3b80d8 

include/atomic

diff --git a/include/atomic b/include/atomic index 644c65c..ee372fa 100644 --- a/include/atomic +++ b/include/atomic @@ -2556,7 +2556,7 @@  atomic_flag() = default;  #else  _LIBCPP_INLINE_VISIBILITY - atomic_flag() : __flg_(false) {}; + atomic_flag() {};  #endif    #ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS 

test/atomics/atomics.flag/atomic_flag_clear.pass.cpp

diff --git a/test/atomics/atomics.flag/atomic_flag_clear.pass.cpp b/test/atomics/atomics.flag/atomic_flag_clear.pass.cpp new file mode 100644 index 0000000..9c52bcc --- /dev/null +++ b/test/atomics/atomics.flag/atomic_flag_clear.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <atomic> + +// struct atomic_flag + +// void atomic_flag_clear(volatile atomic_flag*); +// void atomic_flag_clear(atomic_flag*); + +#include <atomic> +#include <cassert> + +int main() +{ + { + std::atomic_flag f; + f.test_and_set(); + atomic_flag_clear(&f); + assert(f.test_and_set() == 0); + } + { + volatile std::atomic_flag f; + f.test_and_set(); + atomic_flag_clear(&f); + assert(f.test_and_set() == 0); + } +} 

test/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp

diff --git a/test/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp b/test/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp new file mode 100644 index 0000000..af3573b --- /dev/null +++ b/test/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp @@ -0,0 +1,70 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <atomic> + +// struct atomic_flag + +// void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order); +// void atomic_flag_clear_explicit(atomic_flag*, memory_order); + +#include <atomic> +#include <cassert> + +int main() +{ + { + std::atomic_flag f; + f.test_and_set(); + atomic_flag_clear_explicit(&f, std::memory_order_relaxed); + assert(f.test_and_set() == 0); + } + { + std::atomic_flag f; + f.test_and_set(); + atomic_flag_clear_explicit(&f, std::memory_order_consume); + assert(f.test_and_set() == 0); + } + { + std::atomic_flag f; + f.test_and_set(); + atomic_flag_clear_explicit(&f, std::memory_order_release); + assert(f.test_and_set() == 0); + } + { + std::atomic_flag f; + f.test_and_set(); + atomic_flag_clear_explicit(&f, std::memory_order_seq_cst); + assert(f.test_and_set() == 0); + } + { + volatile std::atomic_flag f; + f.test_and_set(); + atomic_flag_clear_explicit(&f, std::memory_order_relaxed); + assert(f.test_and_set() == 0); + } + { + volatile std::atomic_flag f; + f.test_and_set(); + atomic_flag_clear_explicit(&f, std::memory_order_consume); + assert(f.test_and_set() == 0); + } + { + volatile std::atomic_flag f; + f.test_and_set(); + atomic_flag_clear_explicit(&f, std::memory_order_release); + assert(f.test_and_set() == 0); + } + { + volatile std::atomic_flag f; + f.test_and_set(); + atomic_flag_clear_explicit(&f, std::memory_order_seq_cst); + assert(f.test_and_set() == 0); + } +} 

test/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp

diff --git a/test/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp b/test/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp new file mode 100644 index 0000000..e89e560 --- /dev/null +++ b/test/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <atomic> + +// struct atomic_flag + +// bool atomic_flag_test_and_set(volatile atomic_flag*); +// bool atomic_flag_test_and_set(atomic_flag*); + +#include <atomic> +#include <cassert> + +int main() +{ + { + std::atomic_flag f; + f.clear(); + assert(atomic_flag_test_and_set(&f) == 0); + assert(f.test_and_set() == 1); + } + { + volatile std::atomic_flag f; + f.clear(); + assert(atomic_flag_test_and_set(&f) == 0); + assert(f.test_and_set() == 1); + } +} 

test/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp

diff --git a/test/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp b/test/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp new file mode 100644 index 0000000..f98a4cf --- /dev/null +++ b/test/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp @@ -0,0 +1,94 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <atomic> + +// struct atomic_flag + +// bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order); +// bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order); + +#include <atomic> +#include <cassert> + +int main() +{ + { + std::atomic_flag f; + f.clear(); + assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_relaxed) == 0); + assert(f.test_and_set() == 1); + } + { + std::atomic_flag f; + f.clear(); + assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_consume) == 0); + assert(f.test_and_set() == 1); + } + { + std::atomic_flag f; + f.clear(); + assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_acquire) == 0); + assert(f.test_and_set() == 1); + } + { + std::atomic_flag f; + f.clear(); + assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_release) == 0); + assert(f.test_and_set() == 1); + } + { + std::atomic_flag f; + f.clear(); + assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_acq_rel) == 0); + assert(f.test_and_set() == 1); + } + { + std::atomic_flag f; + f.clear(); + assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_seq_cst) == 0); + assert(f.test_and_set() == 1); + } + { + volatile std::atomic_flag f; + f.clear(); + assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_relaxed) == 0); + assert(f.test_and_set() == 1); + } + { + volatile std::atomic_flag f; + f.clear(); + assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_consume) == 0); + assert(f.test_and_set() == 1); + } + { + volatile std::atomic_flag f; + f.clear(); + assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_acquire) == 0); + assert(f.test_and_set() == 1); + } + { + volatile std::atomic_flag f; + f.clear(); + assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_release) == 0); + assert(f.test_and_set() == 1); + } + { + volatile std::atomic_flag f; + f.clear(); + assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_acq_rel) == 0); + assert(f.test_and_set() == 1); + } + { + volatile std::atomic_flag f; + f.clear(); + assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_seq_cst) == 0); + assert(f.test_and_set() == 1); + } +} 

test/atomics/atomics.flag/clear.pass.cpp

diff --git a/test/atomics/atomics.flag/clear.pass.cpp b/test/atomics/atomics.flag/clear.pass.cpp new file mode 100644 index 0000000..59c86a9 --- /dev/null +++ b/test/atomics/atomics.flag/clear.pass.cpp @@ -0,0 +1,82 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <atomic> + +// struct atomic_flag + +// void clear(memory_order = memory_order_seq_cst); +// void clear(memory_order = memory_order_seq_cst) volatile; + +#include <atomic> +#include <cassert> + +int main() +{ + { + std::atomic_flag f; + f.test_and_set(); + f.clear(); + assert(f.test_and_set() == 0); + } + { + std::atomic_flag f; + f.test_and_set(); + f.clear(std::memory_order_relaxed); + assert(f.test_and_set() == 0); + } + { + std::atomic_flag f; + f.test_and_set(); + f.clear(std::memory_order_consume); + assert(f.test_and_set() == 0); + } + { + std::atomic_flag f; + f.test_and_set(); + f.clear(std::memory_order_release); + assert(f.test_and_set() == 0); + } + { + std::atomic_flag f; + f.test_and_set(); + f.clear(std::memory_order_seq_cst); + assert(f.test_and_set() == 0); + } + { + volatile std::atomic_flag f; + f.test_and_set(); + f.clear(); + assert(f.test_and_set() == 0); + } + { + volatile std::atomic_flag f; + f.test_and_set(); + f.clear(std::memory_order_relaxed); + assert(f.test_and_set() == 0); + } + { + volatile std::atomic_flag f; + f.test_and_set(); + f.clear(std::memory_order_consume); + assert(f.test_and_set() == 0); + } + { + volatile std::atomic_flag f; + f.test_and_set(); + f.clear(std::memory_order_release); + assert(f.test_and_set() == 0); + } + { + volatile std::atomic_flag f; + f.test_and_set(); + f.clear(std::memory_order_seq_cst); + assert(f.test_and_set() == 0); + } +} 

test/atomics/atomics.flag/copy_assign.fail.cpp

diff --git a/test/atomics/atomics.flag/copy_assign.fail.cpp b/test/atomics/atomics.flag/copy_assign.fail.cpp new file mode 100644 index 0000000..9d64a50 --- /dev/null +++ b/test/atomics/atomics.flag/copy_assign.fail.cpp @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <atomic> + +// struct atomic_flag + +// atomic_flag& operator=(const atomic_flag&) = delete; + +#include <atomic> +#include <cassert> + +int main() +{ + std::atomic_flag f0; + std::atomic_flag f; + f = f0; +} 

test/atomics/atomics.flag/copy_ctor.fail.cpp

diff --git a/test/atomics/atomics.flag/copy_ctor.fail.cpp b/test/atomics/atomics.flag/copy_ctor.fail.cpp new file mode 100644 index 0000000..169ace6 --- /dev/null +++ b/test/atomics/atomics.flag/copy_ctor.fail.cpp @@ -0,0 +1,23 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <atomic> + +// struct atomic_flag + +// atomic_flag(const atomic_flag&) = delete; + +#include <atomic> +#include <cassert> + +int main() +{ + std::atomic_flag f0; + std::atomic_flag f(f0); +} 

test/atomics/atomics.flag/copy_volatile_assign.fail.cpp

diff --git a/test/atomics/atomics.flag/copy_volatile_assign.fail.cpp b/test/atomics/atomics.flag/copy_volatile_assign.fail.cpp new file mode 100644 index 0000000..3ceacb6 --- /dev/null +++ b/test/atomics/atomics.flag/copy_volatile_assign.fail.cpp @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <atomic> + +// struct atomic_flag + +// atomic_flag& operator=(const atomic_flag&) = delete; + +#include <atomic> +#include <cassert> + +int main() +{ + std::atomic_flag f0; + volatile std::atomic_flag f; + f = f0; +} 

test/atomics/atomics.flag/default.pass.cpp

diff --git a/test/atomics/atomics.flag/default.pass.cpp b/test/atomics/atomics.flag/default.pass.cpp new file mode 100644 index 0000000..c882e03 --- /dev/null +++ b/test/atomics/atomics.flag/default.pass.cpp @@ -0,0 +1,22 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <atomic> + +// struct atomic_flag + +// atomic_flag() = default; + +#include <atomic> +#include <cassert> + +int main() +{ + std::atomic_flag f; +} 

test/atomics/atomics.flag/init.pass.cpp

diff --git a/test/atomics/atomics.flag/init.pass.cpp b/test/atomics/atomics.flag/init.pass.cpp new file mode 100644 index 0000000..24cb854 --- /dev/null +++ b/test/atomics/atomics.flag/init.pass.cpp @@ -0,0 +1,23 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <atomic> + +// struct atomic_flag + +// atomic_flag() = ATOMIC_FLAG_INIT; + +#include <atomic> +#include <cassert> + +int main() +{ + std::atomic_flag f = ATOMIC_FLAG_INIT; + assert(f.test_and_set() == 0); +} 

test/atomics/atomics.flag/test_and_set.pass.cpp

diff --git a/test/atomics/atomics.flag/test_and_set.pass.cpp b/test/atomics/atomics.flag/test_and_set.pass.cpp index cf2b5d7..5bdd32d 100644 --- a/test/atomics/atomics.flag/test_and_set.pass.cpp +++ b/test/atomics/atomics.flag/test_and_set.pass.cpp @@ -19,7 +19,88 @@    int main()  { - std::atomic_flag f; - assert(f.test_and_set() == 0); - assert(f.test_and_set() == 1); + { + std::atomic_flag f; + f.clear(); + assert(f.test_and_set() == 0); + assert(f.test_and_set() == 1); + } + { + std::atomic_flag f; + f.clear(); + assert(f.test_and_set(std::memory_order_relaxed) == 0); + assert(f.test_and_set(std::memory_order_relaxed) == 1); + } + { + std::atomic_flag f; + f.clear(); + assert(f.test_and_set(std::memory_order_consume) == 0); + assert(f.test_and_set(std::memory_order_consume) == 1); + } + { + std::atomic_flag f; + f.clear(); + assert(f.test_and_set(std::memory_order_acquire) == 0); + assert(f.test_and_set(std::memory_order_acquire) == 1); + } + { + std::atomic_flag f; + f.clear(); + assert(f.test_and_set(std::memory_order_release) == 0); + assert(f.test_and_set(std::memory_order_release) == 1); + } + { + std::atomic_flag f; + f.clear(); + assert(f.test_and_set(std::memory_order_acq_rel) == 0); + assert(f.test_and_set(std::memory_order_acq_rel) == 1); + } + { + std::atomic_flag f; + f.clear(); + assert(f.test_and_set(std::memory_order_seq_cst) == 0); + assert(f.test_and_set(std::memory_order_seq_cst) == 1); + } + { + volatile std::atomic_flag f; + f.clear(); + assert(f.test_and_set() == 0); + assert(f.test_and_set() == 1); + } + { + volatile std::atomic_flag f; + f.clear(); + assert(f.test_and_set(std::memory_order_relaxed) == 0); + assert(f.test_and_set(std::memory_order_relaxed) == 1); + } + { + volatile std::atomic_flag f; + f.clear(); + assert(f.test_and_set(std::memory_order_consume) == 0); + assert(f.test_and_set(std::memory_order_consume) == 1); + } + { + volatile std::atomic_flag f; + f.clear(); + assert(f.test_and_set(std::memory_order_acquire) == 0); + assert(f.test_and_set(std::memory_order_acquire) == 1); + } + { + volatile std::atomic_flag f; + f.clear(); + assert(f.test_and_set(std::memory_order_release) == 0); + assert(f.test_and_set(std::memory_order_release) == 1); + } + { + volatile std::atomic_flag f; + f.clear(); + assert(f.test_and_set(std::memory_order_acq_rel) == 0); + assert(f.test_and_set(std::memory_order_acq_rel) == 1); + } + { + volatile std::atomic_flag f; + f.clear(); + assert(f.test_and_set(std::memory_order_seq_cst) == 0); + assert(f.test_and_set(std::memory_order_seq_cst) == 1); + }  }